{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "U_4lIho_ZaWx"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.integrate as integrate\n",
    "import scipy.special as special\n",
    "from scipy.special import factorial as fac\n",
    "from scipy.special import factorial2 as fac2\n",
    "from scipy.integrate import quad, dblquad\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as colors\n",
    "import seaborn as sns\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions for computing Hermite coefficients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functions for computing normalized probabilists hermite coefficients\n",
    "# Define standard normal measure\n",
    "w = lambda x: (1/np.sqrt(2*np.pi))*np.exp(-(x**2)/2)\n",
    "\n",
    "def hermite_coeff(n, act, l = -np.inf, u = np.inf):\n",
    "    H_n = special.hermite(n)\n",
    "    h_n = lambda x: (1/np.sqrt(fac(n)))*(2**(-n/2))*H_n(x/np.sqrt(2))\n",
    "    f = lambda x: act(x)*h_n(x)*w(x)\n",
    "    result,err = integrate.quad(f, l, u)\n",
    "    return result, err\n",
    "\n",
    "\n",
    "def comp_hermite_coeffs(N,act):\n",
    "    coeffs = np.empty(N+1)\n",
    "    errs = np.empty(N+1)\n",
    "    for n in np.arange(0,N+1):\n",
    "        coeffs[n], errs[n] = hermite_coeff(n, act)\n",
    "    return coeffs, errs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes for NTK power series calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class truncated_NTK():\n",
    "    \"\"\"\n",
    "    Approximates the NTK via a truncation of its power series.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, act, L, T, gw, gb, vw, init_EOC = False):\n",
    "        \"\"\"\n",
    "        Parameter descriptions:\n",
    "        - act: string detailing activation function used\n",
    "        - L: positive integer detailing number of hidden layers\n",
    "        - T: positive integer indicating truncation point of the NTK power series\n",
    "        - gw: float/double describing variance of weight initialization in first hidden layer\n",
    "        - gb: float/double describing variance of bias initialization in first hidden layer (note must have gw+gb=1)\n",
    "        - vw: float/double describing variance of weight\n",
    "        - init_EOC: boolean, if true/false then calculate vb such that achieve EOC / unit variance initialization respectively\n",
    "        \n",
    "        \"\"\"\n",
    "        self.tol = 10**-7\n",
    "        self.L = L\n",
    "        self.act = act\n",
    "        self.activation()\n",
    "        self.T = T\n",
    "\n",
    "        # Initialization conditions\n",
    "        self.gw = gw\n",
    "        self.gb = gb\n",
    "        if init_EOC:\n",
    "            print(\"Attempting initialization on the EOC...\")\n",
    "            # Initialize weight variance hyperparameter so that lies on the EOC\n",
    "            self.vw = 1 / gauss_expectation(lambda z: self.dphi(np.sqrt(self.fq) * z) ** 2, ndim=1, fast=True)\n",
    "            # Initilize bias variance so that have variance fixed at fq at each layer, default is 1.\n",
    "            self.vb = self.fq - self.vw * gauss_expectation(lambda z: self.phi(np.sqrt(self.fq) * z) ** 2, ndim=1, fast=True)\n",
    "\n",
    "            if self.vb < 0:\n",
    "                if self.vb > -self.tol:\n",
    "                    self.vb = 0\n",
    "                else:\n",
    "                    print(self.vb)\n",
    "                    raise ValueError(\n",
    "                          \"The bias variance vb cannot be smaller than 0, consider choosing a different activation function\")\n",
    "            else:\n",
    "                print(\"...initialization successful!\")\n",
    "\n",
    "        else:\n",
    "            print(\"Attempting unit variance initializing...\")\n",
    "            self.vw = vw\n",
    "            integrand = lambda x: (self.phi(x)**2)*(1/np.sqrt(2*np.pi))*np.exp(-(x**2)/2)\n",
    "            integral, error = self.vw*integrate.quad(integrand, -np.infty, np.infty)\n",
    "            self.vb = 1 - integral\n",
    "            print(\"Network hyperparameters: gw=\" + str(self.gw) + \", gb=\" + str(self.gb) + \", vw=\" + str(self.vw) + \", vb=\" + str(self.vb))\n",
    "            if (self.gw < 0) or (self.gb < 0) or (self.vw < 0) or (self.vb < 0):\n",
    "                raise ValueError(\n",
    "                        \"Invalid hyperparameter and activation combination for unit variance initialization.\")\n",
    "            print(\"...initialization successful!\")\n",
    "\n",
    "        # Compute coefficients\n",
    "        self.hermite_coeffs,_ = comp_hermite_coeffs(self.T,self.phi)\n",
    "        self.hermite_coeffs_dphi,_ = comp_hermite_coeffs(self.T,self.dphi)        \n",
    "        self.alphas, self.upsilons, self.kappas = self.compute_coeffs()\n",
    "\n",
    "\n",
    "    def compute_coeffs(self):\n",
    "        # Initialize coefficient arrays L x T\n",
    "        alphas = np.empty((self.L, self.T+1))\n",
    "        upsilons = np.empty((self.L, self.T+1))\n",
    "        kappas = np.empty((self.L, self.T+1))\n",
    "    \n",
    "        # Compute coefficients for first hidden layer\n",
    "        alphas[0] = self.vw*(self.hermite_coeffs**2)\n",
    "        alphas[0,0] = alphas[0,0] + self.vb\n",
    "        upsilons[0] = self.vw*(self.hermite_coeffs_dphi**2)\n",
    "        kappas[0,0] = alphas[0,0] + self.gb*upsilons[0,0]\n",
    "        for i in np.arange(1,self.T+1):\n",
    "            kappas[0,i] = alphas[0,i] + + self.gb*upsilons[0,i] + self.gw*upsilons[0,i-1] \n",
    "\n",
    "        # Compute coefficients in subsequent layers\n",
    "        for l in np.arange(1,self.L):\n",
    "            F_array = self.comp_F_array(alphas[l-1])\n",
    "            for p in range(self.T+1):\n",
    "                alphas[l,p] = sum(alphas[0]*F_array[p])\n",
    "                upsilons[l,p] = sum(upsilons[0]*F_array[p])\n",
    "            for p in range(self.T+1):\n",
    "                kappas[l,p] = alphas[l,p]\n",
    "                for q in np.arange(0,p+1):\n",
    "                    kappas[l,p] += kappas[l-1,q]*upsilons[l,p-q]\n",
    "        return alphas, upsilons, kappas\n",
    "\n",
    "  \n",
    "    def comp_F_array(self, v):\n",
    "        F_array = np.empty((self.T+1, self.T+1)) #rows are values of p, columns values of k so F(p,k) = F_array[p, k]\n",
    "        # If k is zero then F(p,0) = 0, F(0,0) = 1\n",
    "        F_array[:,0] = np.zeros(self.T+1)\n",
    "        F_array[0,0] = 1\n",
    "        for k in np.arange(1,self.T+1):\n",
    "            if k == 1:\n",
    "                F_array[:,1] = v\n",
    "            else:\n",
    "                for p in range(self.T+1):\n",
    "                    F_array[p,k] = 0\n",
    "                    for q in np.arange(0,p+1):\n",
    "                        F_array[p,k] += v[q]*F_array[p-q,k-1]\n",
    "        return F_array\n",
    "\n",
    "\n",
    "    def evaluate(self, rho):\n",
    "        outputs = np.empty(self.L)\n",
    "        for l in range(self.L):\n",
    "            outputs[l] = sum(np.array([rho**p for p in range(self.T)])*self.kappas[l])\n",
    "        return outputs\n",
    "\n",
    "    def compute_chi(self):\n",
    "        integrand = lambda x: (self.dphi(x)**2)*(1/np.sqrt(2*np.pi))*np.exp(-(x**2)/2)\n",
    "        integral, error = integrate.quad(integrand, -np.infty, np.infty)\n",
    "        return self.vw*integral\n",
    "\n",
    "\n",
    "    def activation(self):\n",
    "        if act == 'Tanh':\n",
    "            self.phi = lambda x: np.tanh(x)\n",
    "            self.dphi = lambda x: 1 - np.tanh(x)**2\n",
    "\n",
    "        elif act == 'ReLU':\n",
    "            self.phi = lambda x: max(0,x)\n",
    "            self.dphi = lambda x: max(0,np.sign(x))\n",
    "\n",
    "        elif act == \"Sigmoid\":\n",
    "            self.phi = lambda x: 1/(1+np.exp(-x))\n",
    "            self.dphi = lambda x: (1/(1+np.exp(-x)))*(1-(1/(1+np.exp(-x))))\n",
    "\n",
    "        elif act == 'Elu':\n",
    "            self.phi = lambda x: min(np.sign(x),0)*(np.exp(x)-1) + max(0,x)\n",
    "            self.dphi = lambda x: min(np.sign(x),0)*(np.exp(x)) + max(0,np.sign(x))\n",
    "\n",
    "        elif act == 'Gaussian':\n",
    "            self.phi = lambda x: (1/np.sqrt(2*np.pi))*np.exp(-(x**2)/2)\n",
    "            self.dphi = lambda x: -(x/np.sqrt(2*np.pi))*np.exp(-(x**2)/2)\n",
    "        else:\n",
    "            print(\"Activation function not recognized\")\n",
    "\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class truncated_relu_NTK():\n",
    "    \"\"\"\n",
    "    Approximates specifically ReLU via truncated NTK power series. In comparison with truncated_NTK()\n",
    "    uses closed form expressions for the Hermite coefficients of ReLU instead of numerical approximation and\n",
    "    automatically initializes on the EOC / uses standard initialization.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, L, T, gw, gb):\n",
    "        \"\"\"\n",
    "        Parameter descriptions:\n",
    "        - L: positive integer detailing number of hidden layers\n",
    "        - T: positive integer indicating truncation point of the NTK power series\n",
    "        - gw: float/double describing variance of weight initialization in first hidden layer\n",
    "        - gb: float/double describing variance of bias initialization in first hidden layer (note must have gw+gb=1)\n",
    "        \"\"\"\n",
    "        self.L = L\n",
    "        self.phi = lambda x: max(0,x)\n",
    "        self.dphi = lambda x: max(0,np.sign(x))\n",
    "        self.T = T\n",
    "        self.gw = gw\n",
    "        self.gb = gb    \n",
    "        self.vw = 2\n",
    "        self.vb = 0\n",
    "        \n",
    "        # Uses closed form expressions to compute the Hermite coefficients of ReLU\n",
    "        self.hermite_coeffs_phi =np.empty(self.T)\n",
    "        self.hermite_coeffs_phi[0] = 1/np.sqrt(2*np.pi)\n",
    "        self.hermite_coeffs_phi[1] = 1/2\n",
    "        for i in np.arange(2,self.T):\n",
    "            if i%2 == 0:\n",
    "                self.hermite_coeffs_phi[i] = fac2(i-3)/np.sqrt(2*np.pi*fac(i))\n",
    "            else:\n",
    "                self.hermite_coeffs_phi[i] = 0\n",
    "        \n",
    "        # Uses closed form expressions to compute the Hermite coefficients of the derivative of ReLU\n",
    "        self.hermite_coeffs_dphi =np.empty(self.T)\n",
    "        self.hermite_coeffs_dphi[0] = 1/2\n",
    "\n",
    "        for i in np.arange(1,self.T):\n",
    "            if i%2 == 0:\n",
    "                self.hermite_coeffs_dphi[i] = 0\n",
    "            else:\n",
    "                self.hermite_coeffs_dphi[i] = fac2(i-2)/np.sqrt(2*np.pi*fac(i))\n",
    "\n",
    "        self.alphas, self.upsilons, self.kappas = self.compute_coeffs()\n",
    "\n",
    "\n",
    "    def compute_coeffs(self):\n",
    "        alphas = np.empty((self.L, self.T))\n",
    "        upsilons = np.empty((self.L, self.T))\n",
    "        kappas = np.empty((self.L, self.T))\n",
    "        # Compute coefficients at first hidden layer\n",
    "        alphas[0] = self.vw*(self.hermite_coeffs_phi**2)\n",
    "        alphas[0,0] = alphas[0,0] + self.vb\n",
    "        upsilons[0] = self.vw*(self.hermite_coeffs_dphi**2)\n",
    "        kappas[0,0] = alphas[0,0] + self.gb*upsilons[0,0]\n",
    "        for i in np.arange(1,self.T):\n",
    "            kappas[0,i] = alphas[0,i] + self.gw*upsilons[0,i-1] + self.gb*upsilons[0,i]\n",
    "        # Compute coefficients at subsequent hidden layers\n",
    "        for l in np.arange(1,self.L):\n",
    "            F_array = self.comp_F_array(alphas[l-1])\n",
    "            for p in range(self.T):\n",
    "                alphas[l,p] = sum(alphas[0]*F_array[p])\n",
    "                if (p < self.T):\n",
    "                    upsilons[l,p] = sum(upsilons[0]*F_array[p,:self.T])\n",
    "\n",
    "            for p in range(self.T):\n",
    "                kappas[l,p] = alphas[l,p]\n",
    "                for q in np.arange(0,p+1):\n",
    "                    kappas[l,p] += kappas[l-1,q]*upsilons[l,p-q]\n",
    "        return alphas, upsilons, kappas\n",
    "\n",
    "  \n",
    "    def comp_F_array(self, v):\n",
    "        F_array = np.empty((self.T, self.T)) #rows are values of p, columns values of k so F(p,k) = F_array[p, k]\n",
    "        # If k is zero then F(p,0) = 0, F(0,0) = 1\n",
    "        F_array[:,0] = np.zeros(self.T)\n",
    "        F_array[0,0] = 1\n",
    "        for k in np.arange(1,self.T):\n",
    "            if k == 1:\n",
    "                F_array[:,1] = v\n",
    "            else:\n",
    "                for p in range(self.T):\n",
    "                    F_array[p,k] = 0\n",
    "                    for q in np.arange(0,p+1):\n",
    "                        F_array[p,k] += v[q]*F_array[p-q,k-1]\n",
    "        return F_array\n",
    "\n",
    "\n",
    "    def evaluate(self, rho):\n",
    "        outputs = np.empty(self.L)\n",
    "        for l in range(self.L):\n",
    "            outputs[l] = sum(np.array([rho**p for p in range(self.T)])*self.kappas[l])\n",
    "        return outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ntk_relu_explicit():\n",
    "    \"\"\"\n",
    "    Class for computing NTK with ReLU activation function explicitly.\n",
    "    \"\"\"\n",
    "    def __init__(self, L, fq=1):\n",
    "        self.L = L # L is the number of hidden layers, total number of layers is L+1\n",
    "        self.fq = fq # fixed point of variance function\n",
    "\n",
    "    def corr_func_fixed(self, rho):\n",
    "        return (rho/2)+(np.sqrt(1-rho**2) + rho*np.arcsin(rho))/np.pi\n",
    "\n",
    "    def corr_func_diff_fixed(self, rho):\n",
    "        return 0.5 + np.arcsin(rho)/np.pi\n",
    "\n",
    "    def evaluate(self, rho):\n",
    "        outputs = np.empty(self.L+1)\n",
    "        rhos = np.empty(self.L+1)\n",
    "        rhos[0] = rho\n",
    "        outputs[0] = rho\n",
    "        for l in range(self.L):\n",
    "            rhos[l+1] = self.corr_func_fixed(rhos[l])\n",
    "            outputs[l+1] = rhos[l+1] + outputs[l] * self.corr_func_diff_fixed(rhos[l])\n",
    "        return outputs[1:]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error of Truncated ReLU NTK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = 5\n",
    "relu_ntk = ntk_relu_explicit(L)\n",
    "relu_ntks_truncs = {}\n",
    "Ts = [5,50]\n",
    "for T in Ts:\n",
    "    relu_ntks_truncs[T] = truncated_relu_NTK(L, T, 1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = 200\n",
    "rhos = np.linspace(-1,1,M)\n",
    "\n",
    "outputs_relu_trunc = {}\n",
    "for T in Ts:\n",
    "    outputs_relu_trunc[T] = np.empty((M,L))\n",
    "\n",
    "outputs_relu= np.empty((M,L))\n",
    "\n",
    "\n",
    "for m in np.arange(M):\n",
    "    outputs_relu[m] = relu_ntk.evaluate(rhos[m])\n",
    "    for T in Ts:\n",
    "        outputs_relu_trunc[T][m] = relu_ntks_truncs[T].evaluate(rhos[m])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ls = [0,2,4]\n",
    "errors = {}\n",
    "for T in Ts:\n",
    "    errors[T] = np.empty((L,M))\n",
    "    for l in Ls:\n",
    "        errors[T][l] = np.abs(outputs_relu[:,l] - outputs_relu_trunc[T][:,l])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,1,figsize = (12,8))\n",
    "cols = {5:'g', 50:'b'}\n",
    "alph = {0:0.9, 2:0.4, 4:0.2}\n",
    "\n",
    "for l in Ls:\n",
    "    for T in [5,50]:\n",
    "        sns.lineplot(x=rhos, y=errors[T][l],  label=\"T=\"+str(T) + \", L=\"+str(l+1), axes = ax, color = cols[T],alpha=alph[l])\n",
    "\n",
    "ax.set_yscale('log')\n",
    "ax.set(xlabel=r\"$\\rho$\", ylabel = r\"|$\\Theta(\\rho)$ - $\\Theta_T(\\rho)$|\", title=\"Error of truncated NTK\")\n",
    "plt.grid(True)\n",
    "plt.savefig(\"error_truncated_ntk.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error of Truncated ReLU NTK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attempting unit variance initializing...\n",
      "Network hyperparameters: gw=0.5, gb=0.5, vw=1, vb=0.49999999999999956\n",
      "...initialization successful!\n",
      "Attempting unit variance initializing...\n",
      "Network hyperparameters: gw=0.5, gb=0.5, vw=1, vb=0.6057055096021591\n",
      "...initialization successful!\n",
      "Attempting unit variance initializing...\n",
      "Network hyperparameters: gw=0.5, gb=0.5, vw=1, vb=0.7066209641419072\n",
      "...initialization successful!\n",
      "Attempting unit variance initializing...\n",
      "Network hyperparameters: gw=0.5, gb=0.5, vw=1, vb=0.9081118507630347\n",
      "...initialization successful!\n"
     ]
    }
   ],
   "source": [
    "N = 5\n",
    "gw = 1/2\n",
    "gb = 1/2\n",
    "vw = 1\n",
    "\n",
    "act_names = ['ReLU', 'Tanh', 'Sigmoid', 'Gaussian']\n",
    "act_dict_ntks = dict.fromkeys(act_names, [])\n",
    "act_dict_kappas = dict.fromkeys(act_names, [])\n",
    "\n",
    "for act in act_names:\n",
    "    act_dict_ntks[act] = truncated_NTK(act, 1, N, gw, gb, vw)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ReLU</th>\n",
       "      <td>52.276996</td>\n",
       "      <td>82.582161</td>\n",
       "      <td>93.192491</td>\n",
       "      <td>94.076685</td>\n",
       "      <td>95.402976</td>\n",
       "      <td>95.800863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tanh</th>\n",
       "      <td>53.888523</td>\n",
       "      <td>91.468259</td>\n",
       "      <td>93.725179</td>\n",
       "      <td>97.486712</td>\n",
       "      <td>98.154594</td>\n",
       "      <td>99.089628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sigmoid</th>\n",
       "      <td>93.600034</td>\n",
       "      <td>99.729065</td>\n",
       "      <td>99.822221</td>\n",
       "      <td>99.977481</td>\n",
       "      <td>99.985746</td>\n",
       "      <td>99.997316</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gaussian</th>\n",
       "      <td>95.833608</td>\n",
       "      <td>96.798764</td>\n",
       "      <td>98.729077</td>\n",
       "      <td>99.091010</td>\n",
       "      <td>99.633911</td>\n",
       "      <td>99.747015</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  0          1          2          3          4          5\n",
       "ReLU      52.276996  82.582161  93.192491  94.076685  95.402976  95.800863\n",
       "Tanh      53.888523  91.468259  93.725179  97.486712  98.154594  99.089628\n",
       "Sigmoid   93.600034  99.729065  99.822221  99.977481  99.985746  99.997316\n",
       "Gaussian  95.833608  96.798764  98.729077  99.091010  99.633911  99.747015"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = []\n",
    "for act in act_names:\n",
    "    data.append(np.cumsum(act_dict_ntks[act].kappas)/(1+ act_dict_ntks[act].compute_chi()))\n",
    "\n",
    "data = 100*np.array(data)\n",
    "\n",
    "displayN = 6\n",
    "df=pd.DataFrame(data=data[:,:displayN], index=[act for act in act_names],columns=[str(i) for i in np.arange(displayN)])\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{rrrrrr}\n",
      "\\toprule\n",
      "      0 &       1 &       2 &       3 &       4 &       5 \\\\\n",
      "\\midrule\n",
      " 52.277 &  82.582 &  93.192 &  94.077 &  95.403 &  95.801 \\\\\n",
      " 53.889 &  91.468 &  93.725 &  97.487 &  98.155 &  99.090 \\\\\n",
      " 93.600 &  99.729 &  99.822 &  99.977 &  99.986 &  99.997 \\\\\n",
      " 95.834 &  96.799 &  98.729 &  99.091 &  99.634 &  99.747 \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pd.options.display.precision = 3\n",
    "print(df.to_latex(index=False))"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "provenance": []
  },
  "kernelspec": {
   "display_name": "pic16a",
   "language": "python",
   "name": "pic16a"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
